Python Django vahevara: päringute töötlemise torustik

Django, kõrgetasemeline Pythoni veebiraamistik, pakub veebiarendusele jõulist ja elegantset lähenemist. Selle funktsionaalsuse keskmes on päringute töötlemise torustik, tegevuste jada, mis muudab toored sissetulevad päringud mõttekateks vastusteks. Selle torustiku kriitiline komponent on **vahevara**, mis võimaldab arendajatel lisada kohandatud loogikat ja käitumist päringu töötlemise erinevates punktides.

Django päringute töötlemise tsükli mõistmine

Enne vahevarasse süvenemist on oluline mõista Django päringu põhivoolu. Kui kasutaja teeb Django rakendusele päringu, toimuvad tavaliselt järgmised sammud:

• WSGI server saab päringu: Veebiserveri väravainterfaasi (WSGI) server (nagu Gunicorn või uWSGI) saab kliendilt HTTP-päringu.
• Vahevara töötlemine (sissetulev): Päring läbitakse vahevara virnast, järjekorras, mis on määratletud teie failis `settings.py`. Igal vahevara komponendil on võimalus päringut töödelda enne, kui see jõuab vaatesse. Siin toimub autentimine, autoriseerimine, seansihaldus ja muud eeltöötluse ülesanded.
• URL-i resolutsioon: Django URL-i lahendaja uurib taotletud URL-i ja määrab sobiva vaatefunktsiooni selle käsitlemiseks.
• Vaate täitmine: Määratud vaatefunktsioon täidetakse, mis tavaliselt hõlmab andmebaasiga suhtlemist, vastuse sisu genereerimist ja HTTP-vastuse ettevalmistamist.
• Vahevara töötlemine (väljuv): Vastus läbitakse seejärel vahevara virnast, vastupidises järjekorras. Siin saab teha selliseid ülesandeid nagu päiste lisamine, vastuse tihendamine ja küpsiste seadistamine.
• WSGI server saadab vastuse: WSGI server saadab lõpuks HTTP-vastuse tagasi kliendile.

Mis on Django vahevara?

Django vahevara on Django päringu/vastuse töötlemise konksude raamistik. See on ühendatav klasside komplekt, mis globaalselt muudab Django sisendit või väljundit. Mõelge sellele kui filtrite seeriale, mis asuvad veebiserveri ja vaatefunktsioonide vahel, pealtkuulates ja muutes päringuid ja vastuseid.

Vahevara võimaldab teil:

• Muuta päringut enne, kui see jõuab vaatesse (nt lisada päiseid, teostada autentimist).
• Muuta vastust enne, kui see saadetakse kliendile (nt lisada päiseid, tihendada sisu).
• Otsustada, kas lubada või keelata päringul vaateni jõuda.
• Teha tegevusi enne ja pärast vaate täitmist (nt logimine, profileerimine).

Django vaikevahevara haldab põhilisi funktsioone, nagu:

• Seansi haldamine
• Autentimine
• Sõnumite kuvamine (nt õnnestumise ja tõrketeated)
• GZIP-tihendamine

Miks kasutada vahevara? Eelised ja kasud

Vahevara pakub mitmeid olulisi eeliseid:

• Koodi taaskasutatavus: Vahevara loogikat saab taaskasutada mitmes vaates ja projektides, vältides liigset koodi. Näiteks autentimise rakendamise asemel igas vaates saate kasutada vahevara selle globaalseks haldamiseks.
• Murede eraldamine: See aitab eraldada muresid, isoleerides ristlõikelisi funktsioone, nagu autentimine, autoriseerimine, logimine ja vahemällu salvestamine, teie vaatefunktsioonide äri loogikast. See muudab teie koodi puhtamaks, hooldatavamaks ja arusaadavamaks.
• Globaalne mõju: Vahevara mõjutab iga päringut ja vastust, muutes selle võimsaks vahendiks järjepideva käitumise jõustamisel teie rakenduses.
• Paindlikkus ja laiendatavus: Django vahevarasüsteem on väga paindlik. Saate hõlpsalt lisada, eemaldada või muuta vahevara komponente, et kohandada oma rakenduse käitumist. Saate kirjutada oma kohandatud vahevara, et lahendada väga spetsiifilisi vajadusi, mis on kohandatud teie konkreetsele projektile.
• Jõudluse optimeerimine: Teatud vahevara, nagu vahemällu salvestamise vahevara, võib oluliselt parandada teie rakenduse jõudlust, vähendades koormust teie andmebaasile ja veebiserverile.

Kuidas Django vahevara töötab: töötlemise järjekord

Järjekord, milles vahevaraklassid on määratletud failis `settings.py`, on ülioluline. Django töötleb vahevara konkreetses järjekorras, kõigepealt päringu faasis (ülevalt alla) ja seejärel vastuse faasis (alt üles).

Päringu faas: Vahevara rakendatakse sissetulevale päringule järjekorras, nagu need on määratletud seades `MIDDLEWARE`.

Vastuse faas: Vastus läbib vahevara vastupidises järjekorras. See tähendab, et viimane vahevara, mis on määratletud seades `MIDDLEWARE`, hakkab vastust esimesena töötlema ja esimene vahevara on viimane.

Selle järjekorra mõistmine on ülioluline, et kontrollida, kuidas teie vahevara suhtleb ja vältida ootamatut käitumist.

Vahevara konfigureerimine failis `settings.py`

Seade `MIDDLEWARE` failis `settings.py` on vahevara peamine konfiguratsioonipunkt. See on stringide loend, millest igaüks esindab vahevaraklassi teed.

Siin on lihtsustatud näide:

            MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

            

              
                Copy
              
            
          

See konfiguratsioon sisaldab Django vaikevahevara, mis haldab olulisi ülesandeid. Saate lisada oma kohandatud vahevara, lisades oma vahevaraklassi tee sellesse loendisse, tagades, et see on õiges järjekorras võrreldes olemasoleva vahevaraga.

Kohandatud Django vahevara kirjutamine

Kohandatud vahevara loomine hõlmab Pythoni klassi määratlemist, millel on konkreetsed meetodid, mis pealt kuulata ja muuta päringu/vastuse tsüklit. Peamised meetodid, mida saate rakendada, on:

• `__init__(self, get_response)`: Seda kutsutakse ainult üks kord, kui vahevara on lähtestatud. Tavaliselt salvestate kutsutava `get_response` eksemplarimuutujana hilisemaks kasutamiseks. See parameeter tähistab järgmist vahevara ahelas või vaatefunktsiooni, kui see on viimane vahevara.
• `__call__(self, request)`: Seda meetodit kutsutakse iga päringu puhul. See on teie vahevara tuum, kus teete oma töötlemise. See saab sisendina päringu objekti ja peaks tagastama kas objekti `HttpResponse` või tulemuse, helistades `get_response(request)`.
• `process_request(self, request)`: Kutsutakse enne vaate kutsumist. See saab päringu objekti. Saate muuta objekti `request` või tagastada objekti `HttpResponse`, et lühendada päringut. Kui tagastate `None`, jätkub päring järgmisele vahevarale või vaatele.
• `process_view(self, request, view_func, view_args, view_kwargs)`: Kutsutakse vahetult enne, kui Django kutsub vaate. See saab objekti `request`, vaatefunktsiooni ja kõik vaatele edastatud argumendid. Saate muuta päringut või vaate argumente. Objekti `HttpResponse` tagastamine lühendab protsessi.
• `process_response(self, request, response)`: Kutsutakse pärast vaate kutsumist ja vastuse genereerimist. See saab objekti `request` ja objekti `response`. Saate muuta objekti `response`. See *peab* tagastama objekti `response` (muudetud või muutmata).
• `process_exception(self, request, exception)`: Kutsutakse, kui päringu töötlemise ajal (kas vahevaras või vaates) tekib erand. See saab objekti `request` ja erandi objekti. Saate tagastada objekti `HttpResponse`, et käsitleda erandit ja lühendada protsessi, või tagastada `None`, et võimaldada Djangol erandit oma vaikeviisil käsitseda.

Näide: lihtne kohandatud vahevara (päringute logimine)

Loome vahevara, et logida iga sissetulev päring. Looge oma Django rakenduses fail nimega `middleware.py`.

            # Failis myapp/middleware.py
import logging

logger = logging.getLogger(__name__)

class RequestLoggingMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        # Kood, mida täidetakse iga päringu puhul enne vaate kutsumist
        logger.info(f'Päring vastu võetud: {request.method} {request.path}')
        response = self.get_response(request)
        # Kood, mida täidetakse iga päringu/vastuse puhul pärast vaate kutsumist
        return response

            

              
                Copy
              
            
          

Seejärel lisage see vahevara oma faili `settings.py`:

            MIDDLEWARE = [
    # ... muu vahevara ...
    'myapp.middleware.RequestLoggingMiddleware',
]

            

              
                Copy
              
            
          

Nüüd logib vahevara iga kord, kui päring saabub, päringu meetodi ja tee teie logidesse.

Näide: päiste päringute muutmine

Siin on näide vahevarast, mis lisab igale vastusele kohandatud päise:

            # Failis myapp/middleware.py
class AddCustomHeaderMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        response = self.get_response(request)
        response['X-Custom-Header'] = 'Tere vahevarast!'
        return response

            

              
                Copy
              
            
          

Ärge unustage seda lisada oma loendisse `MIDDLEWARE` failis `settings.py`.

Django vahevara levinud kasutusjuhtumid ja näited

Vahevara on mitmekülgne. Siin on mõned levinud kasutusjuhtumid koos näidetega:

• Autentimine ja autoriseerimine: Kasutaja mandaatide ja juurdepääsuõiguste kontrollimine enne teatud vaadetele juurdepääsu lubamist. Django `AuthenticationMiddleware` tegeleb sellega. Kohandatud vahevara võib seda laiendada, et toetada erinevaid autentimismeetodeid (nt API-võtmed, OAuth) või rakendada rollipõhist juurdepääsukontrolli.
• Seansi haldamine: Kasutajaseansside haldamine kasutajaspetsiifiliste andmete salvestamiseks ja toomiseks. Django `SessionMiddleware` tegeleb sellega vaikimisi.
• CSRF-kaitse: Kaitse saidiüleste päringute võltsimise rünnakute eest. Django `CsrfViewMiddleware` rakendab CSRF-kaitset.
• GZIP-tihendamine: Vastuste tihendamine ribalaiuse kasutamise vähendamiseks ja lehe laadimisaegade parandamiseks. Django `GZipMiddleware` tegeleb sellega.
• Logimine ja jälgimine: Päringute, vigade ja jõudlusnäitajate logimine. Eelmises näites demonstreeriti päringute logimist. Vahevara saab kasutada jälgimisvahenditega integreerimiseks.
• Sisuturbe poliitika (CSP): Turvapeade seadmine, et kaitsta erinevate veebirikkumiste eest. Vahevara saab seada päise `Content-Security-Policy`, et piirata sisu allikaid, mida brauser saab laadida.
• Vahemällu salvestamine: Sagedasti kasutatavate andmete vahemällu salvestamine jõudluse parandamiseks. Django sisseehitatud vahemällu salvestamise raamistik ja kolmanda osapoole vahevara pakuvad seda funktsionaalsust.
• URL-i ümbersuunamine: Kasutajate ümbersuunamine erinevatele URL-idele teatud tingimustel (nt kasutaja keel, seadme tüüp).
• Päringu muutmine: Päringuobjekti muutmine (nt päiste lisamine, päringu atribuutide seadmine). Seda kasutatakse tavaliselt selliste ülesannete puhul nagu `REMOTE_ADDR` seadmine, kui teie rakendus töötab proksi taga.
• Vastuse muutmine: Vastuseobjekti muutmine (nt päiste lisamine, sisu muutmine).
• Määra piiramine: Piirata konkreetse IP-aadressi päringute arvu väärkasutuse vältimiseks.
• Rahvusvahelistamine (i18n) ja lokaliseerimine (l10n): Päringute keele ja lokaadi seadmine vastavalt kasutaja eelistustele või brauseri seadetele. Django `LocaleMiddleware` tegeleb sellega.

Näide: põhiline autentimise rakendamine

Loome vahevara, mis nõuab kõigile lehtedele juurdepääsuks kasutajanime ja parooli (demonstratsiooni eesmärgil *ärge* kasutage seda tootmises ilma nõuetekohaste turvakaalutlusteta).

            # Failis myapp/middleware.py
from django.http import HttpResponse
from django.contrib.auth import authenticate, login

class BasicAuthMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        if not request.user.is_authenticated:
            auth_header = request.META.get('HTTP_AUTHORIZATION')
            if auth_header:
                try:
                    auth_type, auth_string = auth_header.split(' ', 1)
                    if auth_type.lower() == 'basic':
                        import base64
                        auth_decoded = base64.b64decode(auth_string).decode('utf-8')
                        username, password = auth_decoded.split(':', 1)
                        user = authenticate(username=username, password=password)
                        if user is not None:
                            login(request, user)
                        else:
                            return HttpResponse('Volitamata', status=401, headers={'WWW-Authenticate': 'Basic realm="Piiratud ala"'})
                except Exception:
                    return HttpResponse('Volitamata', status=401, headers={'WWW-Authenticate': 'Basic realm="Piiratud ala"'})
            else:
                return HttpResponse('Volitamata', status=401, headers={'WWW-Authenticate': 'Basic realm="Piiratud ala"'})
        return self.get_response(request)

            

              
                Copy
              
            
          

Failis `settings.py` lisage see seadesse `MIDDLEWARE`:

            MIDDLEWARE = [
    # ... muu vahevara ...
    'myapp.middleware.BasicAuthMiddleware',
]

            

              
                Copy
              
            
          

See vahevara kontrollib iga päringu põhilist autentimispäist. Kui päis on olemas, proovib see kasutajat autentida. Kui autentimine ebaõnnestub, tagastab see vastuse „Volitamata“. Kui autentimine õnnestub, laseb see päringul vaadete kaudu edasi pääseda.

Näide: päringu määra piiramise rakendamine

Määra piiramine aitab vältida kuritarvitamist ja kaitseb teie serverit ülekoormamise eest. Järgmine näide pakub lihtsustatud rakenduse.

            # Failis myapp/middleware.py
import time
from django.http import HttpResponse, HttpResponseTooManyRequests
from django.conf import settings

class RateLimitMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response
        self.requests = {}

    def __call__(self, request):
        ip_address = self.get_client_ip(request)
        now = time.time()

        if ip_address:
            if ip_address not in self.requests:
                self.requests[ip_address] = {
                    'count': 0,
                    'last_request': now
                }
            
            if settings.RATE_LIMIT_WINDOW:
                if now - self.requests[ip_address]['last_request'] > settings.RATE_LIMIT_WINDOW:
                    self.requests[ip_address]['count'] = 0
                    self.requests[ip_address]['last_request'] = now

            self.requests[ip_address]['count'] += 1
            self.requests[ip_address]['last_request'] = now

            if settings.RATE_LIMIT_REQUESTS and self.requests[ip_address]['count'] > settings.RATE_LIMIT_REQUESTS:
                return HttpResponseTooManyRequests('Liiga palju päringuid.')

        return self.get_response(request)

    def get_client_ip(self, request):
        x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
        if x_forwarded_for:
            ip = x_forwarded_for.split(',')[0].strip()
        else:
            ip = request.META.get('REMOTE_ADDR')
        return ip

            

              
                Copy
              
            
          

Määratlege oma failis `settings.py` need sätted:

            RATE_LIMIT_REQUESTS = 10  # Maksimaalsed päringud akna kohta
RATE_LIMIT_WINDOW = 60  # Sekundid

            

              
                Copy
              
            
          

Lisage see seadesse `MIDDLEWARE`:

            MIDDLEWARE = [
    # ... muu vahevara ...
    'myapp.middleware.RateLimitMiddleware',
]

            

              
                Copy
              
            
          

See vahevara piirab päringuid kliendi IP-aadressi põhjal. Kohandage `RATE_LIMIT_REQUESTS` ja `RATE_LIMIT_WINDOW`, et konfigureerida määra piiramist.

Django vahevara arendamise parimad tavad

Nende parimate tavade järgimine tagab, et teie vahevara on tõhus, hooldatav ja ei tekita jõudluse kitsaskohti:

• Hoidke see lihtsana: Vahevara peaks keskenduma konkreetsetele, hästi määratletud ülesannetele. Vältige keerukat loogikat või liigseid sõltuvusi.
• Ole jõudlusega: Vahevara täidetakse iga päringu/vastuse korral. Optimeerige oma koodi, et minimeerida töötlemisaega. Vältige vahevaras blokeerivaid toiminguid või tarbetuid andmebaasipäringuid.
• Testige põhjalikult: Kirjutage üksustestid, et tagada, et teie vahevara töötab õigesti ja käitub ootuspäraselt erinevates stsenaariumides. Testige äärejuhtumeid ja vigade käsitlemist.
• Dokumenteerige selgelt: Esitage selge dokumentatsioon, mis selgitab, mida teie vahevara teeb, kuidas see töötab ja kuidas seda konfigureerida. Kaasake näiteid ja kasutusjuhiseid.
• Järgige Django konventsioone: Järgige Django kodeerimisstiili ja konventsioone. See muudab teie koodi loetavamaks ja teiste arendajate jaoks hõlpsamini mõistetavaks.
• Kaaluge jõudluse tagajärgi: Hinnake hoolikalt oma vahevara potentsiaalset jõudlust, eriti kui see hõlmab ressursimahukaid toiminguid.
• Käsitlege erandeid graatsiliselt: Rakendage korralikku vigade käsitlemist, et vältida teie vahevara kokkuvarisemist teie rakenduses. Kasutage bloke `try...except`, et püüda potentsiaalseid erandeid ja logida vigu. Kasutage `process_exception()` põhjalikuks erandite käsitlemiseks.
• Järjekord on oluline: Kaaluge hoolikalt oma vahevara järjekorda seades `MIDDLEWARE`. Veenduge, et vahevara on paigutatud õigesse järjekorda, et saavutada soovitud käitumine ja vältida konflikte.
• Vältige päringu/vastuse tarbetut muutmist: Muutke päringu/vastuse objekte ainult siis, kui see on vajalik soovitud käitumise saavutamiseks. Tarbetud muudatused võivad põhjustada jõudlusprobleeme.

Täpsemad vahevara tehnikad ja kaalutlused

Lisaks põhitõdedele on siin mõned täpsemad tehnikad:

• Vahevara kasutamine asünkroonsete ülesannete jaoks: Saate kasutada vahevara asünkroonsete ülesannete, näiteks meilide saatmise või andmete töötlemise taustal, algatamiseks. Kasutage nende toimingute haldamiseks Celeryt või muid ülesannete järjekordi.
• Vahevara tehased: Keerukamate konfiguratsioonide jaoks saate kasutada vahevara tehaseid, mis on funktsioonid, mis võtavad konfiguratsiooniargumente ja tagastavad vahevaraklassid. See on kasulik, kui peate vahevara lähtestama parameetritega, mis on määratletud failis `settings.py`.
• Tingimuslik vahevara: Saate tinglikult lubada või keelata vahevara vastavalt seadetele või keskkonnamuutujatele. See võimaldab teil kohandada oma rakenduse käitumist erinevate keskkondade jaoks (nt arendus, testimine, tootmine).
• API määra piirava vahevara: Rakendage keerukaid määra piiramise tehnikaid oma API lõpp-punktide jaoks. Kaaluge kolmandate osapoolte teekide või spetsiaalsete teenuste (nt Redis) kasutamist määra piiramise andmete salvestamiseks.
• Integreerimine kolmandate osapoolte teekidega: Saate oma vahevara sujuvalt integreerida kolmandate osapoolte teekidega ja tööriistadega. Näiteks integreerige jälgimisvahenditega mõõdikute kogumiseks ja jõudluse jälgimiseks.

Näide: vahevara tehase kasutamine

See näide demonstreerib lihtsat vahevara tehast. See lähenemisviis võimaldab teil konfiguratsiooniparameetreid edastada oma failist `settings.py`.

            # Failis myapp/middleware.py
from django.conf import settings

def my_middleware_factory(setting_key):
    class MyConfigurableMiddleware:
        def __init__(self, get_response):
            self.get_response = get_response
            self.config_value = settings.get(setting_key, 'default_value')  # Loe konfiguratsiooni

        def __call__(self, request):
            # Kasutage self.config_value
            print(f'Konfiguratsiooni väärtus: {self.config_value}')
            return self.get_response(request)
    return MyConfigurableMiddleware

            

              
                Copy
              
            
          

Failis `settings.py` konfigureerige see järgmiselt:

            MIDDLEWARE = [
    # ... muu vahevara ...
    'myapp.middleware.my_middleware_factory', # Märkus: edastage see ilma sulgudeta või argumentideta.
]
MY_CUSTOM_SETTING = 'some_value'

            

              
                Copy
              
            
          

Ja failis `urls.py` või mõnes muus kohas, kus vahevara kasutatakse, saate tehase meetodile edastada konfiguratsiooniseade:

            from myapp.middleware import my_middleware_factory

urlpatterns = [
    # ...muud url mustrid...
    #  Tehase meetodi jaoks ei ole URL-i konfiguratsioonis vaja argumente
]

            

              
                Copy
              
            
          

See lähenemisviis pakub suuremat paindlikkust ja kohandamist.

Levinud probleemid ja tõrkeotsing

Siin on mõned levinud probleemid, millega võite Django vahevaraga töötamisel kokku puutuda, koos lahendustega:

• Vale vahevara järjekord: Kui teie vahevara ei käitu ootuspäraselt, kontrollige uuesti järjekorda failis `settings.py`. Järjekord on kriitiline.
• Vead päringu töötlemise ajal: Kui teie vahevara viskab vea, võib see katkestada kogu päringutsükli. Kasutage meetodit `process_exception()`, et käsitleda erandeid graatsiliselt ja vältida ootamatuid tõrkeid. Samuti veenduge, et teie vahevaras ei oleks tsüklilisi sõltuvusi.
• Jõudluse kitsaskohad: Ebaefektiivne vahevara võib teie rakendust aeglustada. Profileerige oma koodi, et tuvastada jõudluse kitsaskohad ja optimeerida vastavalt. Vältige vahevaras ressursimahukaid toiminguid või delegeerige need taustülesannetele.
• Konflikt teiste vahevaradega: Olge teadlik, et teie vahevara võib olla vastuolus teie projekti teiste vahevaradega või isegi Django vaikevahevaraga. Vaadake hoolikalt dokumentatsiooni üle ja veenduge, et kõik vahevarad suhtlevad õigesti.
• Tahtmatud kõrvalmõjud: Veenduge, et teie vahevara muudab päringu/vastuse objekte ainult ettenähtud viisil. Vältige tahtmatuid kõrvalmõjusid, mis võivad põhjustada ootamatut käitumist.
• Seansiga seotud probleemid: Kui teil on seansiga seotud probleeme, veenduge, et `SessionMiddleware` on teie failis `settings.py` õigesti konfigureeritud ja et seansiandmeid salvestatakse ja neid kasutatakse õigesti.
• CSRF-märgi probleemid: Kui teil on CSRF-märgiga seotud probleeme, veenduge, et `CsrfViewMiddleware` on failis `settings.py` õigesti seadistatud. Kontrollige ka oma vorme õige CSRF-märgi renderdamise suhtes.

Kasutage Django sisseehitatud silumisvahendeid ja logimist probleemide jälgimiseks. Analüüsige päringu/vastuse elutsüklit, et tuvastada probleemide põhjus. Teie vahevara põhjalik testimine enne juurutamist on samuti ülioluline.

Kokkuvõte: Django vahevara valdamine

Django vahevara on põhimõiste iga Django arendaja jaoks. Selle toimimise, konfigureerimise ja kohandatud vahevara loomise mõistmine on oluline tugevate, hooldatavate ja skaleeritavate veebirakenduste loomiseks.

Vahevara valdamisega saate võimsa kontrolli oma rakenduse päringute töötlemise torustiku üle, mis võimaldab teil rakendada laia valikut funktsioone alates autentimisest ja autoriseerimisest kuni jõudluse optimeerimise ja turvalisuse täiustamiseni.

Kui teie projektid keerukuselt kasvavad, muutub võime vahevara tõhusalt kasutada oluliseks oskuseks. Harjutage ja katsetage ning saate osavaks Django vahevarasüsteemi võimsuse kasutamisel.